package com.simple.business.util;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson2.JSONObject;
import com.simple.business.domain.enumeration.EvaluationTypeEnum;
import com.simple.business.domain.vo.evaluation.EvaluationReportDISCVO;
import com.simple.business.domain.vo.evaluation.EvaluationReportHollandVO;
import com.simple.business.domain.vo.evaluation.EvaluationReportMBTIVO;
import com.simple.business.domain.vo.graph.GraphVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @desc
 * @Author Simple
 * @Date 2024/8/22 10:56
 **/
@Slf4j
public class RuleHandleUtil {

    public static String formatOnlineChatTime(LocalDateTime msgDateTime) {
        return formatOnlineChatTime(msgDateTime, false);
    }

    public static String formatOnlineChatTime(LocalDateTime msgDateTime,Boolean dateWithTime) {
        if (msgDateTime == null) {
            return "";
        }
        String formatMsgDateTime;

        if (LocalDateTime.now().toLocalDate().toString().equals(msgDateTime.toLocalDate().toString())) {
            //今天显示：12:12
            formatMsgDateTime = msgDateTime.toLocalTime().toString().substring(0, 5);
        } else if (LocalDateTime.now().plusDays(-1L).toLocalDate().toString().equals(msgDateTime.toLocalDate().toString())) {
            //昨天显示：昨天
            formatMsgDateTime = "昨天";
        } else if (LocalDateTime.now().getYear() == msgDateTime.toLocalDate().getYear()) {
            if (dateWithTime) {
                //今年显示：08-21 13:12
                formatMsgDateTime = msgDateTime.toLocalDate().toString().substring(5) + " " + msgDateTime.toLocalTime().toString().substring(0, 5);
            } else {
                //今年显示：08-21
                formatMsgDateTime = msgDateTime.toLocalDate().toString().substring(5);
            }
        } else {
            //往年显示：2024-08-21
            formatMsgDateTime = msgDateTime.toLocalDate().toString();
        }
        return formatMsgDateTime;
    }

    /**
     * 处理大模型返回的json格式
     * @param origin
     * @return
     */
    public static String dealLLMJsonResult(String origin) {
        String result = origin;
        if (origin.contains("```")) {
            String prefix = origin.contains("```json") ? "```json" : "```";
            result = StringUtils.substringBetween(result, prefix, "```");
        }
        /*if (result.endsWith("}")) {
            result = result.substring(0, result.length() - 1);
        }*/
        return result;
    }

    /**
     * 根据大模型结果，获取单个key对应的value
     * @param origin
     * @return
     */
    public static String dealSingleJsonResult(String origin) {

        try {
            JSONObject jsonObject = JSONObject.parseObject(origin);
            for (String key : jsonObject.keySet()) {
                return jsonObject.getString(key);
            }
        } catch (Exception e) {
        }
        return origin.substring(origin.indexOf(":") + 1)
                .replaceAll("\"","")
                .replaceAll("\\-", "")
                .replaceAll("\\*", "")
                .replaceAll("\\\\n","\n").trim();
    }

    /**
     * 缩短长度
     * @param list
     * @return
     */
    public static String curtailTags(List<String> list) {
        if (CollUtil.isEmpty(list)) {
            return "";
        }
        List<String> tags = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            String newTag = sb.toString() + list.get(i);
            if (newTag.length() < 20) {
                tags.add(list.get(i) + "");
                sb.append(list.get(i)).append("、");
            }
        }
        sb.delete(0, sb.length());
        return StringUtils.join(tags, "、");
    }

    /**
     * 特殊处理结果
     * @param result
     * @return
     */
    public static JSONObject handleFormat(String result) {
        String originResult = result;
        try {
            result = result.substring(1, result.length() - 1).replaceAll("\n", "");
            JSONObject jsonObject = new JSONObject();
            int q1Index = result.indexOf("\"q1\":");
            int q2Index = result.indexOf("\"q2\":");
            int q3Index = result.indexOf("\"q3\":");
            int q4Index = result.indexOf("\"q4\":");
            int q5Index = result.indexOf("\"q5\":");
            int ra1Index = result.indexOf("\"ra1\":");
            int ra2Index = result.indexOf("\"ra2\":");
            int ra3Index = result.indexOf("\"ra3\":");
            int ra4Index = result.indexOf("\"ra4\":");
            int ra5Index = result.indexOf("\"ra5\":");
            List<Integer> list = new ArrayList<>();
            Map<Integer, String> map = new HashMap<>(8);
            fillCollection(q1Index, "q1", list, map);
            fillCollection(q2Index, "q2", list, map);
            fillCollection(q3Index, "q3", list, map);
            fillCollection(q4Index, "q4", list, map);
            fillCollection(q5Index, "q5", list, map);
            fillCollection(ra1Index, "ra1", list, map);
            fillCollection(ra2Index, "ra2", list, map);
            fillCollection(ra3Index, "ra3", list, map);
            fillCollection(ra4Index, "ra4", list, map);
            fillCollection(ra5Index, "ra5", list, map);

            Collections.sort(list);
            for (int i = 0; i < list.size(); i++) {
                Integer currIndex = list.get(i);
                Integer lastIndex = -1;
                if (i < list.size() - 1) {
                    lastIndex = list.get(i + 1);
                } else {
                    lastIndex = result.length();
                }
                String mid = result.substring(currIndex + 3 + map.get(currIndex).length(), lastIndex);
                int midLastIndex = mid.indexOf("\"") != mid.lastIndexOf("\"") ? mid.lastIndexOf("\"") : mid.length();
                mid = mid.substring(mid.indexOf("\"") + 1, midLastIndex);
                jsonObject.put(map.get(currIndex), mid);
            }

            return jsonObject;
        } catch (Exception e) {
            log.info("AI面试生成问题返回结果: " + originResult + "\n");
            log.error("AI面试生成问题异常: " + e.getMessage());
            return null;
        }
    }

    public static void fillCollection(Integer index, String name, List<Integer> list, Map<Integer, String> map) {
        if (index != -1) {
            list.add(index);
            map.put(index, name);
        }
    }

    /**
     * 根据查询类型填充DISC，MBTI，Holland
     * @param origin
     * @param queryType
     * @return
     */
    public static String fillDISCAndMBTIAndHollandInfo(String origin,String queryType) {
        String res = "";
        try {
            JSONObject jsonObject = JSONObject.parseObject(origin);
            if (EvaluationTypeEnum.DISC.eq(queryType)) {
                EvaluationReportDISCVO discVo = RuleHandleUtil.fillDISCInfo(origin);
                if (Objects.isNull(discVo)) {
                    return res;
                }
                res = JSONObject.toJSONString(discVo);
            } else if (EvaluationTypeEnum.MBTI.eq(queryType)) {
                EvaluationReportMBTIVO mbtiVo = RuleHandleUtil.fillMBTIInfo(jsonObject);
                res = JSONObject.toJSONString(mbtiVo);
            } else if (EvaluationTypeEnum.HOLLAND.eq(queryType)) {
                EvaluationReportHollandVO hollandVo = RuleHandleUtil.fillHollandInfo(jsonObject);
                res = JSONObject.toJSONString(hollandVo);
            } else {
                res = "";
            }
        } catch (Exception e) {
            log.error("测评报告-" + EvaluationTypeEnum.get(queryType) + "异常：" + e);
        }
        return res;
    }


    /**
     * 填充DISC
     * @param origin
     * @return
     */
    public static EvaluationReportDISCVO fillDISCInfo(String origin) {
        try {
            EvaluationReportDISCVO discVo = JSONObject.parseObject(origin, EvaluationReportDISCVO.class);
            //User user = new User();
            //discVo.setUserAvatar(user.getAvatar());
            //discVo.setUserId(BaseContextHandler.getUserId());
            discVo.setUserAvatar("");
            discVo.setUserId(0L);

            String discType = discVo.getDiscType();

            if (discVo.getDominance() == null || discVo.getInfluence() == null || discVo.getSteadiness() == null || discVo.getCompliance() == null) {
                return null;
            }

            //如果discType不是DISC类型，那就取分值最高的
            if (!(StringUtils.equalsIgnoreCase(discType, "D") ||
                    StringUtils.equalsIgnoreCase(discType, "I") ||
                    StringUtils.equalsIgnoreCase(discType, "S") ||
                    StringUtils.equalsIgnoreCase(discType, "C"))) {
                Map<Integer, String> scoreMap = new TreeMap<>((o1, o2) -> o2 - o1);
                scoreMap.put(discVo.getDominance(), "D");
                scoreMap.put(discVo.getInfluence(), "I");
                scoreMap.put(discVo.getSteadiness(), "S");
                scoreMap.put(discVo.getCompliance(), "C");
                discType = scoreMap.get(scoreMap.keySet().iterator().next());
            }

            if (!(StringUtils.equalsIgnoreCase(discType, "D") ||
                    StringUtils.equalsIgnoreCase(discType, "I") ||
                    StringUtils.equalsIgnoreCase(discType, "S") ||
                    StringUtils.equalsIgnoreCase(discType, "C"))) {
                // 获取维度分值最高的两个
                Map<Integer, String> scoreMap = new TreeMap<>((o1, o2) -> o2 - o1);
                scoreMap.put(discVo.getTaskOrientation(), "tot");
                scoreMap.put(discVo.getInterpersonalOrientation(), "ipo");
                scoreMap.put(discVo.getInitiative(), "itt");
                scoreMap.put(discVo.getInternalAudit(), "ita");
                String x = discVo.getTaskOrientation() > discVo.getInterpersonalOrientation() ? "tot" : "ipo";
                String y = discVo.getInitiative() > discVo.getInternalAudit() ? "itt" : "ita";

                if ("tot".equals(x) && "itt".equals(y)) {
                    discType = "D";
                } else if ("tot".equals(x) && "ita".equals(y)) {
                    discType = "C";
                } else if ("ipo".equals(x) && "itt".equals(y)) {
                    discType = "I";
                } else if ("ipo".equals(x) && "ita".equals(y)) {
                    discType = "S";
                }
            }
            //DISC对应的分值 封装成数组
            discVo.setDiscScores(Arrays.asList(discVo.getDominance(),discVo.getInfluence(),discVo.getSteadiness(),discVo.getCompliance()));

            if ("D".equalsIgnoreCase(discType)) {
                discVo.setDiscType("D");
                discVo.setDiscTypeName("支配型/指挥者");
                discVo.setPersonalityTraits("支配高且有自己的想法，极擅于让别人依他们的方法做事，会做全盘考虑且为满足自己的需要，他们会透过直接且压迫性的行为掌握环境。但现况不利时，通常能压住反对的声音。");
                discVo.setSuitableJobs(Arrays.asList("企业高管", "项目经理", "投行", "律所合伙人", "客户经理", "管理培训生(MT)"));

                discVo.setXAxis(50 - discVo.getTaskOrientation());
                discVo.setYAxis(discVo.getInitiative());
            } else if ("I".equalsIgnoreCase(discType)) {
                discVo.setDiscType("I");
                discVo.setDiscTypeName("影响型/社交者");
                discVo.setPersonalityTraits("沟通能力强，并对自己社交能力有自信。通常有能力说服他人共同合作。处事较圆滑，对他人的感觉较敏感。非常外向且以人为主，同时珍惜关系，更喜欢人际接触频繁的环境。");
                discVo.setSuitableJobs(Arrays.asList("市场","销售","咨询(BA)","广告、传媒、公关行业的客户执行(AE)","培训讲师"));

                discVo.setXAxis(discVo.getInterpersonalOrientation());
                discVo.setYAxis(discVo.getInitiative());
            } else if ("S".equalsIgnoreCase(discType)) {
                discVo.setDiscType("S");
                discVo.setDiscTypeName("稳健性/支持者");
                discVo.setPersonalityTraits("稳健度处于曲线顶端的人，对大多数组织而言是「纯金」，因为他们不仅是忠诚的员工，也是可信赖的团队成员。他们是按部就班的逻辑思考者，喜欢为一个领袖或目标风斗。");
                discVo.setSuitableJobs(Arrays.asList("行政","客服代表","售后服务专员","人力资源","教育工作者"));

                discVo.setXAxis(discVo.getInterpersonalOrientation());
                discVo.setYAxis(50 - discVo.getInternalAudit());
            } else if ("C".equalsIgnoreCase(discType)) {
                discVo.setDiscType("C");
                discVo.setDiscTypeName("谨慎型/思考者");
                discVo.setPersonalityTraits("尽忠职守、谨慎、遵守他人的规定。天生精准且井然有序。由于思路清晰，只要知道正确的方向为何，就会受到激励，因此他们喜欢规矩和秩序。分析能力强，是最佳品质保证者。");
                discVo.setSuitableJobs(Arrays.asList("数据分析与科学研究","财务会计","硬件工程","风险管理","软件编程"));

                discVo.setXAxis(50 - discVo.getTaskOrientation());
                discVo.setYAxis(50 - discVo.getInternalAudit());
            } else {
                return null;
            }
            return discVo;
        } catch (Exception e) {
            log.error("DISC生成异常: " + e);
            return null;
        }
    }

    /**
     * 填充mbti文字说明
     */
    public static EvaluationReportMBTIVO fillMBTIInfo(JSONObject jsonObject) {

        EvaluationReportMBTIVO mbtiVo = new EvaluationReportMBTIVO();
        if (Objects.isNull(jsonObject)) {
            return mbtiVo;
        }
        String mbtiType = jsonObject.getString("mbtiType");
        mbtiVo.setMbtiType(mbtiType);

        mbtiVo.setMbtidtos(Arrays.asList(
                new GraphVO("外向(E)", Double.valueOf(jsonObject.getInteger("e")), "内向(I)", Double.valueOf(jsonObject.getInteger("i"))),
                new GraphVO("实感(S)", Double.valueOf(jsonObject.getInteger("s")), "直觉(N)", Double.valueOf(jsonObject.getInteger("n"))),
                new GraphVO("理性(T)", Double.valueOf(jsonObject.getInteger("t")), "感性(F)", Double.valueOf(jsonObject.getInteger("f"))),
                new GraphVO("判断(J)", Double.valueOf(jsonObject.getInteger("j")), "知觉(P)", Double.valueOf(jsonObject.getInteger("p")))));

        mbtiVo.setRadarCharts(Arrays.asList(
                new GraphVO("逻辑思维", Double.valueOf(jsonObject.getInteger("logicalThinking"))),
                new GraphVO("专注力", Double.valueOf(jsonObject.getInteger("focusPower"))),
                new GraphVO("独创性", Double.valueOf(jsonObject.getInteger("originality"))),
                new GraphVO("执行力", Double.valueOf(jsonObject.getInteger("executiveForce"))),
                new GraphVO("沟通合作", Double.valueOf(jsonObject.getInteger("communicationCooperation")))));

        if ("INTJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("建筑师");
            mbtiVo.setMbtiContent("富有想象力的战略家，擅长计划和达成长远目标");
            mbtiVo.setMbtiAnalysis("你是完美主义者，强烈要求自主、看重个人能力、对自己的创新思想坚定不移，并受其驱使去实现自己的目标。逻辑性强，有判断力，才华横溢，对人对己要求严格。在所有类型的人中，你的独立性最强，喜欢我行我素。面对反对意见，你通常多疑、霸道、毫不退让。对权威本身，毫不在乎，但只要规章制度有利于你的长远目标就能遵守。");
        } else if ("INTP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("逻辑学家");
            mbtiVo.setMbtiContent("具有创造力的探索者，沉浸在对知识的渴望之中");
            mbtiVo.setMbtiAnalysis("你善于解决抽象问题。你满腹经纶，时常能闪现出创造的睿智火花。你外表恬静，内心专注，总忙于分析问题。你目光挑剔，独立性极高。");
        } else if ("ENTJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("指挥官");
            mbtiVo.setMbtiContent("富有想象力且果断的领导者，善于组织并激励团队向目标前进");
            mbtiVo.setMbtiAnalysis("你是极为有力的领导人和决策者，能明察一切事物中的各种可能性，喜欢发号施令。你是天才的思想家，做事深谋远虑、策划周全。你事事力求做好，生就一双锐眼，能够一针见血地发现问题并迅速找到改进方法。");
        } else if ("ENTP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("辩论家");
            mbtiVo.setMbtiContent("机智的思想家，挑战常规，推动思维边界的辩论");
            mbtiVo.setMbtiAnalysis("你好激动、健谈、聪明、是个多面手。总是孜孜以求地提高自己的能力。你天生有创业心、爱钻研、机敏善变、适应能力强。");
        } else if ("INFJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("提倡者");
            mbtiVo.setMbtiContent("安静神秘，但非常鼓舞人心且不知疲倦的理想主义者");
            mbtiVo.setMbtiAnalysis("你极富创意。你感情强烈、原则性强且具有良好的个人品德，善于独立进行创造性思考。即使面对怀疑，对自己的观点仍坚信不疑。看问题常常更能入木三分。");
        } else if ("INFP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("调停者");
            mbtiVo.setMbtiContent("理想主义的梦想家，追求内心和谐，热衷于正义事业");
            mbtiVo.setMbtiAnalysis("你珍视内在和谐胜过一切。你敏感、理想化、忠心耿耿，在个人价值观方面有强烈的荣誉感。如果能献身自己认为值得的事业，便情绪高涨。在日常生活中，你通常很灵活、有包容心，但对内心热衷的事业义无反顾。很少表露强烈的情感，常显得镇静自若、寡言少语。但一旦相熟，也会变得十分热情。");
        } else if ("ENFJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("主人公");
            mbtiVo.setMbtiContent("富有魅力的引导者，致力于通过教育和支持促进他人成长");
            mbtiVo.setMbtiAnalysis("你有爱心，对生活充满热情。往往对自己很挑剔。不过，由于你自认为要为别人的感受负责，所以很少在公众场合发表批评意见。你对行为的是非曲直明察秋毫，是社交高手。");
        } else if ("ENFP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("竞选者");
            mbtiVo.setMbtiContent("热情洋溢的创作者，善于激励他人，追求多样化的体验");
            mbtiVo.setMbtiAnalysis("你热情奔放，满脑子新观念。乐观、率性、充满自信和创造性，能深刻认识到哪些事可为。对灵感推崇备至，是天生的发明家。你不墨守成规，善于闯新路子。");
        } else if ("ISTJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("物流师");
            mbtiVo.setMbtiContent("可靠的守护者，重视传统和规则，追求高效与秩序");
            mbtiVo.setMbtiAnalysis("你一丝不苟、认真负责，而且明智豁达，是坚定不移的社会维护者，重视传统和忠诚。你讲求实际、非常务实，总是孜孜以求精确性和条理性，而且有极大的专注力。不论干什么，你都能有条不紊、四平八稳地把它完成。");
        } else if ("ISFJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("守卫者");
            mbtiVo.setMbtiContent("温暖的关怀者，注重细节，擅长照顾他人的感受和需求");
            mbtiVo.setMbtiAnalysis("你忠心耿耿、一心一意、富有同情心，喜欢助人为乐。由于这种人有很强的职业道德，一旦觉得自己的行动确有帮助，你便会担起重担。");
        } else if ("ESTJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("总经理");
            mbtiVo.setMbtiContent("务实的指挥官，擅长组织和管理，确保任务顺利完成");
            mbtiVo.setMbtiAnalysis("你适合做理顺事实和政策以及人员组织工作，能够有效利用时间和资源以找出合乎逻辑的解决方案，在目标明确的工作中运用娴熟的技能，你希望工作得到客观公正的评价。");
        } else if ("ESFJ".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("执政官");
            mbtiVo.setMbtiContent("友善关心他人，善于营造和谐氛围，总是乐于助人");
            mbtiVo.setMbtiAnalysis("你喜欢通过直接合作以切实帮助别人。由于你尤其注重人际关系，因而通常很受人欢迎，也喜欢迎合别人。你的态度认真、遇事果断、通常表达意见坚决。");
        } else if ("ISTP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("鉴赏家");
            mbtiVo.setMbtiContent("冷静的分析师，喜欢灵活应对问题，追求技术精湛与效率");
            mbtiVo.setMbtiAnalysis("你奉行实用主义，喜欢行动，不爱空谈。你擅长于分析、敏于观察、好奇心强，只相信可靠确凿的事实。由于非常务实，你能很好地利用一切可能利用的资源，而且很会瞧准时机。");
        } else if ("ISFP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("探险家");
            mbtiVo.setMbtiContent("灵活有魅力的艺术家，时刻准备着探索和体验新鲜事物");
            mbtiVo.setMbtiAnalysis("你本人温柔、体贴、敏感，从不轻言个性化的理想及价值观。你常通过行动，而非语言来表达炽烈的情感。具有耐心、能屈能伸、且十分随和、无意控制他人。你从不妄加评判他人动机。");
        } else if ("ESTP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("企业家");
            mbtiVo.setMbtiContent("聪明且洞察力极强的人，享受刺激与挑战，擅长即兴发挥");
            mbtiVo.setMbtiAnalysis("你无忧无虑，属乐天派。且活泼、随和、率性，喜欢安于现状，不愿从长计议。由于你能够接受现实，一般心胸豁达、包容心强。更喜欢玩实实在在的东西，善于拆拆装装。");
        } else if ("ESFP".equals(mbtiType)) {
            mbtiVo.setMbtiTypeName("表演者");
            mbtiVo.setMbtiContent("热情的社交家，追求快乐与自由，擅长活跃气氛");
            mbtiVo.setMbtiAnalysis("你本人生性爱玩、充满活力，用自己的陶醉来为别人增添乐趣。你适应性强，平易随和，可以热情饱满地同时参加几项活动。你不喜欢把自己的意志强加于人。");
        }
        return mbtiVo;
    }

    /**
     * 填充霍兰德
     * @param jsonObject
     */
    public static EvaluationReportHollandVO fillHollandInfo(JSONObject jsonObject) {
        EvaluationReportHollandVO hollandVo = new EvaluationReportHollandVO();
        if (Objects.isNull(jsonObject)) {
            return hollandVo;
        }
        Integer r = jsonObject.getInteger("r");
        Integer i = jsonObject.getInteger("i");
        Integer a = jsonObject.getInteger("a");
        Integer s = jsonObject.getInteger("s");
        Integer e = jsonObject.getInteger("e");
        Integer c = jsonObject.getInteger("c");

        Map<Integer, String> hollandMap = new TreeMap<>((o1, o2) -> o2 - o1);
        hollandMap.put(r, "R");
        hollandMap.put(i, "I");
        hollandMap.put(a, "A");
        hollandMap.put(s, "S");
        hollandMap.put(e, "E");
        hollandMap.put(c, "C");

        // 霍兰德代码
        String hollandCode = hollandMap.values().stream().collect(Collectors.joining()).substring(0, 3);
        hollandVo.setHollandType(hollandCode);

        //三角图形
        if (StringUtils.isNotEmpty(hollandCode) && hollandCode.length() == 3) {
            hollandVo.setTriangleCharts(Arrays.asList(
                    new GraphVO(hollandCode.substring(0, 1)),
                    new GraphVO(hollandCode.substring(1, 2)),
                    new GraphVO(hollandCode.substring(2, 3))));
        }

        hollandVo.setRadarCharts(Arrays.asList(
                new GraphVO("艺术型", Double.valueOf(a), "A"),
                new GraphVO("研究型", Double.valueOf(i), "I"),
                new GraphVO("实际型", Double.valueOf(r), "R"),
                new GraphVO("传统型", Double.valueOf(c), "C"),
                new GraphVO("企业型", Double.valueOf(e), "E"),
                new GraphVO("社会型", Double.valueOf(s), "S")));

        // 主导兴趣
        String dominantInterestChat = hollandCode.substring(0, 1);
        if ("R".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("现实型");
            hollandVo.setHollandContent("喜欢使用工具进行操作性工作，动手能力强，不善言辞，喜欢独立做事。典型职业包括木匠、电工、机械师等。");
        } else if ("I".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("研究型");
            hollandVo.setHollandContent("抽象思维能力强，喜欢独立和富有创造性的工作，不善于领导他人。典型职业包括科学研究人员、编程人员、医生等。");
        } else if ("A".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("艺术型");
            hollandVo.setHollandContent("有创造力，渴望表现个性，追求完美。典型职业包括演员、导演、艺术设计师等。");
        } else if ("S".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("社会型");
            hollandVo.setHollandContent("喜欢与人交往，关心社会问题，善于谈心。典型职业包括教育工作者、咨询人员、社会工作者等。");
        } else if ("E".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("企业型");
            hollandVo.setHollandContent("追求权力、权威和物质财富，喜欢竞争和冒险。典型职业包括项目经理、销售人员、政府官员等。");
        } else if ("C".equals(dominantInterestChat)) {
            hollandVo.setDominantInterest("常规型");
            hollandVo.setHollandContent("尊重权威和规章制度，喜欢按计划办事，细心有条理。典型职业包括秘书、办公室人员、会计等。");
        }
        return hollandVo;
    }


}
